logo

Trait anoma_apps::std::prelude::v1::PartialEq

1.0.0 · source · [−]
pub trait PartialEq<Rhs = Self> where
    Rhs: ?Sized, {
    fn eq(&self, other: &Rhs) -> bool;

    fn ne(&self, other: &Rhs) -> bool { ... }
}
Expand description

Trait for equality comparisons which are partial equivalence relations.

x.eq(y) can also be written x == y, and x.ne(y) can be written x != y. We use the easier-to-read infix notation in the remainder of this documentation.

This trait allows for partial equality, for types that do not have a full equivalence relation. For example, in floating point numbers NaN != NaN, so floating point types implement PartialEq but not Eq.

Implementations must ensure that eq and ne are consistent with each other:

  • a != b if and only if !(a == b) (ensured by the default implementation).

If PartialOrd or Ord are also implemented for Self and Rhs, their methods must also be consistent with PartialEq (see the documentation of those traits for the exact requirements). It’s easy to accidentally make them disagree by deriving some of the traits and manually implementing others.

The equality relation == must satisfy the following conditions (for all a, b, c of type A, B, C):

  • Symmetric: if A: PartialEq<B> and B: PartialEq<A>, then a == b implies b == a; and

  • Transitive: if A: PartialEq<B> and B: PartialEq<C> and A: PartialEq<C>, then a == b and b == c implies a == c.

Note that the B: PartialEq<A> (symmetric) and A: PartialEq<C> (transitive) impls are not forced to exist, but these requirements apply whenever they do exist.

Derivable

This trait can be used with #[derive]. When derived on structs, two instances are equal if all fields are equal, and not equal if any fields are not equal. When derived on enums, each variant is equal to itself and not equal to the other variants.

How can I implement PartialEq?

An example implementation for a domain in which two books are considered the same book if their ISBN matches, even if the formats differ:

enum BookFormat {
    Paperback,
    Hardback,
    Ebook,
}

struct Book {
    isbn: i32,
    format: BookFormat,
}

impl PartialEq for Book {
    fn eq(&self, other: &Self) -> bool {
        self.isbn == other.isbn
    }
}

let b1 = Book { isbn: 3, format: BookFormat::Paperback };
let b2 = Book { isbn: 3, format: BookFormat::Ebook };
let b3 = Book { isbn: 10, format: BookFormat::Paperback };

assert!(b1 == b2);
assert!(b1 != b3);

How can I compare two different types?

The type you can compare with is controlled by PartialEq’s type parameter. For example, let’s tweak our previous code a bit:

// The derive implements <BookFormat> == <BookFormat> comparisons
#[derive(PartialEq)]
enum BookFormat {
    Paperback,
    Hardback,
    Ebook,
}

struct Book {
    isbn: i32,
    format: BookFormat,
}

// Implement <Book> == <BookFormat> comparisons
impl PartialEq<BookFormat> for Book {
    fn eq(&self, other: &BookFormat) -> bool {
        self.format == *other
    }
}

// Implement <BookFormat> == <Book> comparisons
impl PartialEq<Book> for BookFormat {
    fn eq(&self, other: &Book) -> bool {
        *self == other.format
    }
}

let b1 = Book { isbn: 3, format: BookFormat::Paperback };

assert!(b1 == BookFormat::Paperback);
assert!(BookFormat::Ebook != b1);

By changing impl PartialEq for Book to impl PartialEq<BookFormat> for Book, we allow BookFormats to be compared with Books.

A comparison like the one above, which ignores some fields of the struct, can be dangerous. It can easily lead to an unintended violation of the requirements for a partial equivalence relation. For example, if we kept the above implementation of PartialEq<Book> for BookFormat and added an implementation of PartialEq<Book> for Book (either via a #[derive] or via the manual implementation from the first example) then the result would violate transitivity:

ⓘ
#[derive(PartialEq)]
enum BookFormat {
    Paperback,
    Hardback,
    Ebook,
}

#[derive(PartialEq)]
struct Book {
    isbn: i32,
    format: BookFormat,
}

impl PartialEq<BookFormat> for Book {
    fn eq(&self, other: &BookFormat) -> bool {
        self.format == *other
    }
}

impl PartialEq<Book> for BookFormat {
    fn eq(&self, other: &Book) -> bool {
        *self == other.format
    }
}

fn main() {
    let b1 = Book { isbn: 1, format: BookFormat::Paperback };
    let b2 = Book { isbn: 2, format: BookFormat::Paperback };

    assert!(b1 == BookFormat::Paperback);
    assert!(BookFormat::Paperback == b2);

    // The following should hold by transitivity but doesn't.
    assert!(b1 == b2); // <-- PANICS
}

Examples

let x: u32 = 0;
let y: u32 = 1;

assert_eq!(x == y, false);
assert_eq!(x.eq(&y), false);

Required methods

This method tests for self and other values to be equal, and is used by ==.

Provided methods

This method tests for !=.

Implementations on Foreign Types

source

impl PartialEq<_Unwind_Reason_Code> for _Unwind_Reason_Code

source

impl PartialEq<_Unwind_Action> for _Unwind_Action

Equality check against string literal (satisfies &ClientId == &str).

use core::str::FromStr;
use ibc::core::ics24_host::identifier::ClientId;
let client_id = ClientId::from_str("clientidtwo");
assert!(client_id.is_ok());
client_id.map(|id| {assert_eq!(&id, "clientidtwo")});

Equality check against string literal (satisfies &ConnectionId == &str).

use core::str::FromStr;
use ibc::core::ics24_host::identifier::ConnectionId;
let conn_id = ConnectionId::from_str("connectionId-0");
assert!(conn_id.is_ok());
conn_id.map(|id| {assert_eq!(&id, "connectionId-0")});

Equality check against string literal (satisfies &ChannelId == &str).

Performs a case-insensitive comparison of the string against the header name

Examples
let content_length = AsciiMetadataKey::from_static("content-length");

assert_eq!(content_length, "content-length");
assert_eq!(content_length, "Content-Length");
assert_ne!(content_length, "content length");

Performs a case-insensitive comparison of the string against the header name

Performs a case-insensitive comparison of the string against the header name

Examples
let content_length = AsciiMetadataKey::from_static("content-length");

assert_eq!(content_length, "content-length");
assert_eq!(content_length, "Content-Length");
assert_ne!(content_length, "content length");

Performs a case-insensitive comparison of the string against the header name

Case-insensitive equality

Case-insensitive equality

Examples

let authority: Authority = "HELLO.com".parse().unwrap();
assert_eq!(authority, "hello.coM");
assert_eq!("hello.com", authority);

Performs a case-insensitive comparison of the string against the header name

Examples
use http::header::CONTENT_LENGTH;

assert_eq!(CONTENT_LENGTH, "content-length");
assert_eq!(CONTENT_LENGTH, "Content-Length");
assert_ne!(CONTENT_LENGTH, "content length");

Case-insensitive equality

Examples

let scheme: Scheme = "HTTP".parse().unwrap();
assert_eq!(scheme, *"http");

Performs a case-insensitive comparison of the string against the header name

Performs a case-insensitive comparison of the string against the header name

Performs a case-insensitive comparison of the string against the header name

Examples
use http::header::CONTENT_LENGTH;

assert_eq!(CONTENT_LENGTH, "content-length");
assert_eq!(CONTENT_LENGTH, "Content-Length");
assert_ne!(CONTENT_LENGTH, "content length");

impl PartialEq<_libc_xmmreg> for _libc_xmmreg

impl PartialEq<__c_anonymous_ptrace_syscall_info_exit> for __c_anonymous_ptrace_syscall_info_exit

impl PartialEq<_libc_fpstate> for _libc_fpstate

impl PartialEq<__c_anonymous_ptrace_syscall_info_seccomp> for __c_anonymous_ptrace_syscall_info_seccomp

impl PartialEq<_libc_fpxreg> for _libc_fpxreg

impl PartialEq<__timeval> for __timeval

impl PartialEq<__c_anonymous_ptrace_syscall_info_data> for __c_anonymous_ptrace_syscall_info_data

impl PartialEq<__exit_status> for __exit_status

impl PartialEq<__c_anonymous_ptrace_syscall_info_entry> for __c_anonymous_ptrace_syscall_info_entry

impl PartialEq<__c_anonymous_sockaddr_can_tp> for __c_anonymous_sockaddr_can_tp

impl PartialEq<__c_anonymous_sockaddr_can_j1939> for __c_anonymous_sockaddr_can_j1939

impl PartialEq<input_keymap_entry> for input_keymap_entry

This implementation is constant time, if the slice is the same length as the hash.

This implementation is constant time, if the two hashes are the same length.

Within an ISA, register classes are uniquely identified by their index.

Checks if both handles point to the same collector.

This implementation is constant-time.

This implementation is constant-time.

This implementation is constant-time if the target is 32 bytes long.

URLs compare like their serialization.

Used for matching levels in conformance tests

Used for matching levels in conformance tests

Equality or records, as defined by RFC 2136, DNS Update, April 1997

  1.1.1. Two RRs are considered equal if their NAME, CLASS, TYPE,
  RDLENGTH and RDATA fields are equal.  Note that the time-to-live
  (TTL) field is explicitly excluded from the comparison.

  1.1.2. The rules for comparison of character strings in names are
  specified in [RFC1035 2.3.3]. i.e. case insensitive

Compares two JsValues for equality, using the === operator in JS.

MDN documentation

URLs compare like their serialization.

Deal with the logical numeric equivalent.

Examples
use byte_unit::{Byte, ByteUnit};

let byte1 = Byte::from_unit(1024f64, ByteUnit::KiB).unwrap();
let byte2 = Byte::from_unit(1024f64, ByteUnit::KiB).unwrap();

assert_eq!(byte1.get_appropriate_unit(false), byte2.get_appropriate_unit(true));
use byte_unit::{Byte, ByteUnit};

let byte1 = Byte::from_unit(1024f64, ByteUnit::KiB).unwrap();
let byte2 = Byte::from_unit(1f64, ByteUnit::MiB).unwrap();

assert_eq!(byte1.get_appropriate_unit(true), byte2.get_appropriate_unit(false));

Implementors